BaseAuthService - Code Metrics - Inspection of "Basic Auth Service + user, userInitialized, replac..." - cothema/ionic-universal-firebase-login - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( be82c0...67261f )

by Miloš

created 2020-02-04 22:14 UTC

BaseAuthService A

↳ Parent: src/services/base-auth-service.ts

Complexity

Total Complexity

Size/Duplication

Total Lines	206
Duplicated Lines	0 %

Importance

Changes

Metric	Value
wmc	22
eloc	163
dl	0
loc	206
rs	10
c	0
b	0
f	0

14 Functions

Rating	Name	Size	Complexity
A	redirectAfterLogin	5	2
A	signInAnonymously	11	1
A	signOut	15	3
A	signInViaEmail	11	1
A	signInByProvider	21	3
A	redirectAfterSignOut	4	2
A	signInViaTwitter	11	1
A	subscribeUserChanges	14	2
A	updateUserData	5	1
A	signInViaGoogle	11	1
A	getUser	9	2
A	signInViaGithub	11	1
A	signInViaFacebook	11	1
A	signInViaPhone	11	1

import { Injectable } from "@angular/core";
import { AngularFireAuth } from "@angular/fire/auth";
import { Router } from "@angular/router";
import { Platform } from "@ionic/angular";
import { auth as firebaseAuth, User as FirebaseUser } from "firebase";
import { auth } from "firebase/app";
import { Observable } from "rxjs";
import { UniFirebaseLoginConfig } from "../config/uni-firebase-login-config";
import { UniFirebaseLoginConfigProvider } from "../config/uni-firebase-login-config-provider";
import { UserModel } from "../model/user-model";
import { AuthProvider } from "../providers/auth-provider";
import { IAuthProvider } from "../providers/i-auth-provider";
import { AuthStorageProvider } from "../storage/auth-storage-provider.service";
import { IAuthService } from "./i-auth-service";

@Injectable({
    providedIn: "root",
})
export class BaseAuthService<User extends UserModel = UserModel>
    implements IAuthService {
    public get user(): User | null {
        return this._user;
    }

    public get userInitialized() {
        return this._userInitialized;
    }

    public get currentFirebaseUser(): FirebaseUser | null {
        return firebaseAuth().currentUser;
    }
    protected config: UniFirebaseLoginConfig;
    protected _user: User | null = null;
    protected _userInitialized: boolean = false;

    public constructor(
        protected router: Router,
        protected platform: Platform,
        protected authProvider: AuthProvider,
        protected authStorageProvider: AuthStorageProvider<User>,
        protected angularFireAuth: AngularFireAuth,
        configProvider: UniFirebaseLoginConfigProvider,
    ) {
        this.config = configProvider.config;
        this.subscribeUserChanges();
    }

    public async signInByProvider(
        provider: IAuthProvider,
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        const credential = await provider.handleLogin();
        if (
            this.config.storage !== false &&
            credential &&
            credential.user !== null
        ) {
            await this.authStorageProvider
                .getProvider()
                .updateStoredDataByFirebaseUser(credential.user);
        }
        await callbackBeforeRedirect(credential);
        if (redirect) {
            await this.redirectAfterLogin();
        }
    }

    public async signInAnonymously(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authAnonymous,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaEmail(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authEmail,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaFacebook(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authFacebook,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaGithub(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authGithub,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaGoogle(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authGoogle,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaPhone(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authPhone,
            redirect,
            callbackBeforeRedirect,
        );
    }

    public async signInViaTwitter(
        redirect: boolean = true,
        callbackBeforeRedirect: (
            credential: auth.UserCredential | null,
        ) => Promise<void> | void = () => undefined,
    ): Promise<void> {
        await this.signInByProvider(
            this.authProvider.authTwitter,
            redirect,
            callbackBeforeRedirect,
        );
    }

    /**
     * Handle sign out request
     */
    public async signOut(): Promise<void> {
        const currentUser = auth().currentUser;

        if (currentUser) {
            const providers = this.authProvider.getProvidersByUser(currentUser);

            for (const provider of providers) {
                await provider.handleSignOut();
            }
        }
        await this.redirectAfterSignOut();
    }

    /**
     * Get user profile data
     */
    public getUser(fromCache: boolean = true): Observable<User | null> {
        if (fromCache) {
            return this.authStorageProvider.getUser();
        } else {
            return this.authStorageProvider.getUserNonCached();
        }
    }

    public async updateUserData(user: User) {
        await this.authStorageProvider
            .getProvider()
            .updateStoredDataByUser(user);
    }

    protected async redirectAfterSignOut() {
        if (this.config.signInPage) {
            await this.router.navigate([this.config.signInPage]);
        }
    }

    protected async redirectAfterLogin() {
        if (this.config.afterSignInPage) {
            console.log("Redirect ", this.config.afterSignInPage);
            await this.router.navigate([this.config.afterSignInPage]);
        }
    }

    private subscribeUserChanges(): void {
        this.angularFireAuth.user.subscribe((user: any) => {
            this._userInitialized = true;
            if (user) {
                this.authStorageProvider
                    .getProvider()
                    .fetchUserFromStorageByFirebaseUser(user)
                    .subscribe(result => {
                        this._user = result;
                    });
            } else {
                // Logged out
                this._user = null;
            }
        });
    }
}


1			import { Injectable } from "@angular/core";
2			import { AngularFireAuth } from "@angular/fire/auth";
3			import { Router } from "@angular/router";
4			import { Platform } from "@ionic/angular";
5			import { auth as firebaseAuth, User as FirebaseUser } from "firebase";
6			import { auth } from "firebase/app";
7			import { Observable } from "rxjs";
8			import { UniFirebaseLoginConfig } from "../config/uni-firebase-login-config";
9			import { UniFirebaseLoginConfigProvider } from "../config/uni-firebase-login-config-provider";
10			import { UserModel } from "../model/user-model";
11			import { AuthProvider } from "../providers/auth-provider";
12			import { IAuthProvider } from "../providers/i-auth-provider";
13			import { AuthStorageProvider } from "../storage/auth-storage-provider.service";
14			import { IAuthService } from "./i-auth-service";
15
16			@Injectable({
17			providedIn: "root",
18			})
19			export class BaseAuthService<User extends UserModel = UserModel>
20			implements IAuthService {
21			public get user(): User \| null {
22			return this._user;
23			}
24
25			public get userInitialized() {
26			return this._userInitialized;
27			}
28
29			public get currentFirebaseUser(): FirebaseUser \| null {
30			return firebaseAuth().currentUser;
31			}
32			protected config: UniFirebaseLoginConfig;
33			protected _user: User \| null = null;
34			protected _userInitialized: boolean = false;
35
36			public constructor(
37			protected router: Router,
38			protected platform: Platform,
39			protected authProvider: AuthProvider,
40			protected authStorageProvider: AuthStorageProvider<User>,
41			protected angularFireAuth: AngularFireAuth,
42			configProvider: UniFirebaseLoginConfigProvider,
43			) {
44			this.config = configProvider.config;
45			this.subscribeUserChanges();
46			}
47
48			public async signInByProvider(
49			provider: IAuthProvider,
50			redirect: boolean = true,
51			callbackBeforeRedirect: (
52			credential: auth.UserCredential \| null,
53			) => Promise<void> \| void = () => undefined,
54			): Promise<void> {
55			const credential = await provider.handleLogin();
56			if (
57			this.config.storage !== false &&
58			credential &&
59			credential.user !== null
60			) {
61			await this.authStorageProvider
62			.getProvider()
63			.updateStoredDataByFirebaseUser(credential.user);
64			}
65			await callbackBeforeRedirect(credential);
66			if (redirect) {
67			await this.redirectAfterLogin();
68			}
69			}
70
71			public async signInAnonymously(
72			redirect: boolean = true,
73			callbackBeforeRedirect: (
74			credential: auth.UserCredential \| null,
75			) => Promise<void> \| void = () => undefined,
76			): Promise<void> {
77			await this.signInByProvider(
78			this.authProvider.authAnonymous,
79			redirect,
80			callbackBeforeRedirect,
81			);
82			}
83
84			public async signInViaEmail(
85			redirect: boolean = true,
86			callbackBeforeRedirect: (
87			credential: auth.UserCredential \| null,
88			) => Promise<void> \| void = () => undefined,
89			): Promise<void> {
90			await this.signInByProvider(
91			this.authProvider.authEmail,
92			redirect,
93			callbackBeforeRedirect,
94			);
95			}
96
97			public async signInViaFacebook(
98			redirect: boolean = true,
99			callbackBeforeRedirect: (
100			credential: auth.UserCredential \| null,
101			) => Promise<void> \| void = () => undefined,
102			): Promise<void> {
103			await this.signInByProvider(
104			this.authProvider.authFacebook,
105			redirect,
106			callbackBeforeRedirect,
107			);
108			}
109
110			public async signInViaGithub(
111			redirect: boolean = true,
112			callbackBeforeRedirect: (
113			credential: auth.UserCredential \| null,
114			) => Promise<void> \| void = () => undefined,
115			): Promise<void> {
116			await this.signInByProvider(
117			this.authProvider.authGithub,
118			redirect,
119			callbackBeforeRedirect,
120			);
121			}
122
123			public async signInViaGoogle(
124			redirect: boolean = true,
125			callbackBeforeRedirect: (
126			credential: auth.UserCredential \| null,
127			) => Promise<void> \| void = () => undefined,
128			): Promise<void> {
129			await this.signInByProvider(
130			this.authProvider.authGoogle,
131			redirect,
132			callbackBeforeRedirect,
133			);
134			}
135
136			public async signInViaPhone(
137			redirect: boolean = true,
138			callbackBeforeRedirect: (
139			credential: auth.UserCredential \| null,
140			) => Promise<void> \| void = () => undefined,
141			): Promise<void> {
142			await this.signInByProvider(
143			this.authProvider.authPhone,
144			redirect,
145			callbackBeforeRedirect,
146			);
147			}
148
149			public async signInViaTwitter(
150			redirect: boolean = true,
151			callbackBeforeRedirect: (
152			credential: auth.UserCredential \| null,
153			) => Promise<void> \| void = () => undefined,
154			): Promise<void> {
155			await this.signInByProvider(
156			this.authProvider.authTwitter,
157			redirect,
158			callbackBeforeRedirect,
159			);
160			}
161
162			/**
163			* Handle sign out request
164			*/
165			public async signOut(): Promise<void> {
166			const currentUser = auth().currentUser;
167
168			if (currentUser) {
169			const providers = this.authProvider.getProvidersByUser(currentUser);
170
171			for (const provider of providers) {
172			await provider.handleSignOut();
173			}
174			}
175			await this.redirectAfterSignOut();
176			}
177
178			/**
179			* Get user profile data
180			*/
181			public getUser(fromCache: boolean = true): Observable<User \| null> {
182			if (fromCache) {
183			return this.authStorageProvider.getUser();
184			} else {
185			return this.authStorageProvider.getUserNonCached();
186			}
187			}
188
189			public async updateUserData(user: User) {
190			await this.authStorageProvider
191			.getProvider()
192			.updateStoredDataByUser(user);
193			}
194
195			protected async redirectAfterSignOut() {
196			if (this.config.signInPage) {
197			await this.router.navigate([this.config.signInPage]);
198			}
199			}
200
201			protected async redirectAfterLogin() {
202			if (this.config.afterSignInPage) {
203			console.log("Redirect ", this.config.afterSignInPage);
204			await this.router.navigate([this.config.afterSignInPage]);
205			}
206			}
207
208			private subscribeUserChanges(): void {
209			this.angularFireAuth.user.subscribe((user: any) => {
210			this._userInitialized = true;
211			if (user) {
212			this.authStorageProvider
213			.getProvider()
214			.fetchUserFromStorageByFirebaseUser(user)
215			.subscribe(result => {
216			this._user = result;
217			});
218			} else {
219			// Logged out
220			this._user = null;
221			}
222			});
223			}
224			}
225

cothema / ionic-universal-firebase-login

Push — master ( be82c0...67261f )

BaseAuthService A

Complexity

Size/Duplication

Importance

14 Functions

Duplication Side-by-Side

Filter issues like